﻿using System;
using System.Collections.Generic;
using System.Text;

namespace Rance.Battle
{
    class 侠客AI_守护 : 侠客AI
    {
        public override AIResult Excute(角色 角色, 队伍状况 队伍状况, AI技能MGT 技能mgt)
        {
            var 准备Count = 队伍状况.对手状态.队伍.成员List.FindAll(r => r.是否准备).Count;

            if (准备Count == 0)
            {
                //使用"舍生取义"几率:
                //剩余回合数: 25 70
                //剩余回合数: 20 55
                //剩余回合数: 15 40
                //剩余回合数: 10 20
                //剩余回合数: 5 -10
                //剩余回合数: 0 -40
                //-------------------------
                //剩余队友数: 5 +35
                //剩余队友数: 4 +30
                //剩余队友数: 3 +15
                //剩余队友数: 2 +5
                //剩余队友数: 1 -10
                //剩余队友数: 0 0
                //-------------------------
                //行动力:4 +30
                //行动力:3 +20
                //行动力:2 0
                //行动力:1 -20

                if (技能mgt.Has("舍生取义"))
                {
                    int 守护几率 = 0;
                    if (队伍状况.战场.剩余回合数 >= 25)
                        守护几率 = 70;
                    else if (队伍状况.战场.剩余回合数 >= 20)
                        守护几率 = 55;
                    else if (队伍状况.战场.剩余回合数 >= 15)
                        守护几率 = 40;
                    else if (队伍状况.战场.剩余回合数 >= 10)
                        守护几率 = 20;
                    else if (队伍状况.战场.剩余回合数 >= 5)
                        守护几率 = -10;
                    else if (队伍状况.战场.剩余回合数 >= 0)
                        守护几率 = -40;

                    switch (角色.行动点)
                    {
                        case 1:
                            守护几率 -= 20;
                            break;
                        case 2:
                            break;
                        case 3:
                            守护几率 += 30;
                            break;
                        default:
                            守护几率 += 40;
                            break;
                    }

                    int 剩余队友数 = 队伍状况.队伍.成员List.FindAll(r =>
                    {
                        if(r == 角色)
                            return false;

                        if (r.是否败退 && r.行动点 == 0)
                            return false;
                        if (r.防御赋予 != null)
                            return false;

                        return true;
                    }).Count;

                    switch (剩余队友数)
                    {
                        case 5:
                            守护几率 += 35;
                            break;
                        case 4:
                            守护几率 += 30;
                            break;
                        case 3:
                            守护几率 += 15;
                            break;
                        case 2:
                            守护几率 += 5;
                            break;
                        case 1:
                            守护几率 -= 10;
                            break;
                        case 0:
                            守护几率 = 0;
                            break;
                    }

                    bool hit = false;
                    if (守护几率 >= 100)
                        hit = true;
                    else if (守护几率 > 0)
                        hit = 队伍状况.战场.AI乱数表.Hit(守护几率);

                    if (hit)
                    {
                        AIResult result = new AIResult();
                        var 舍生取义 = 技能mgt.Get("舍生取义");
                        var 舍生取义target = get守护Target(ConvertSoloTarget(舍生取义.TargetList), 队伍状况);
                        if (舍生取义target != null)
                        {
                            result.Action = 舍生取义.Name;
                            result.TargetList.Add(舍生取义target);

                            return result;
                        }
                    }
                }
            }

            return base.Excute(角色, 队伍状况, 技能mgt);
        }

        private 角色 get守护Target(List<角色> targetList, 队伍状况 队伍状况)
        {
            targetList = targetList.FindAll(m => (m.防御赋予 == null && m.行动点 > 0));
            if (targetList.Count == 0)
                return null;


            //优先强化"步卒"
            List<角色> tempList = targetList.FindAll(r =>
                {
                    return r.兵种.类型 == "步卒";
                });

            if (tempList.Count == 0)
                tempList = targetList;

            tempList.Sort((v1, v2) => {
                var temp = v1.列.CompareTo(v2.列);
                if (temp == 0)
                {
                    var temp2 = v2.兵力.CompareTo(v1.兵力);
                    if (temp2 == 0)
                        return (v2.实际攻 + v2.实际防 + v2.实际速 + v2.实际智).CompareTo(v1.实际攻 + v1.实际防 + v1.实际速 + v1.实际智);
                    else
                        return temp2;
                }
                else
                    return temp;
            
            });

            return tempList[0];
        }

        private static 侠客AI_守护 instance = new 侠客AI_守护();
        public static 侠客AI_守护 GetInstance()
        {
            return instance;
        }
    }
}
